package halfsync_halfasync;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

/**
 * @Author: linKe
 * @Date: 2022/1/15 11:09
 * @FileName: Test
 * @version: 1.0
 * @Description: 使用示例
 * halfsync_halfasync
 * 高效并发模式
 * 为了提高系统的吞吐量，请求处理分为两层同步层和异步层。
 * 同步层通过Selector轮询channel获取的事件，而事件的处理则是通过其它工作线程来异步完成。
 * 两层之间通过一个队列来协调，这样事件的处理过程就不会阻塞轮询线程，可以让不同channel的事件获得更快的响应，
 * 不同事件的处理可以同步进行，大大提高了系统的吞吐量。
 */
public class Test {
    public static void main(String[] args) {
        XAsyncTask task = new XAsyncTask();
        List<Future<String>> results = new ArrayList<Future<String>>();
        try {
            results.add(task.doSomething("Hello", 1));
            results.add(task.doSomething("Pattern", 2));

            for (Future<String> f : results) {
                // Future 异步计算所采取的动作发生在另一个线程中对应的Future.get()之后的动作之前。
                System.out.println(f.get());
                /*

                    main message 1:Hello
                    main message 2:Pattern
                    AsyncTaskDefaultWorker message 1:Hello
                    AsyncTaskDefaultWorker message 2:Pattern
                 */
            }
            Thread.sleep(200);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static class XAsyncTask extends AsyncTask<String> {

        @Override
        protected String doInBackground(Object... params) {
            String message = (String) params[0];
            Integer sequence = (Integer) params[1];
            return Thread.currentThread().getName() + " message " + sequence + ":" + message;
        }

        @Override
        protected void onPreExecute(Object... params) {
            String message = (String) params[0];
            Integer sequence = (Integer) params[1];
            System.out.println(Thread.currentThread().getName() + " message " + sequence + ":" + message);
        }

        /**
         * 对外服务方法
         * @param message 消息
         * @param sequence
         * @return
         */
        public Future<String> doSomething(String message, int sequence) {
            if (sequence < 0) {
                throw new IllegalArgumentException("Invalid sequence: " + sequence);
            }
            return dispatch(message, sequence);
        }

    }
}
